\chapter{Implementazione del compilatore}

In questo capitolo viene mostrata un'estensione del linguaggio
{\flang} chiamato {\cflang} e la sua compilazione in un'estensione del linguaggio
{\olang} chiamato {\colang}.
Successivamente viene illustrata la compilazione dal linguaggio {\colang} al linguaggio Java. 

\section{\label{sec:cflang}Il linguaggio \cflang}
\lstset{language=[Objective]Caml,
      print=true,
      basicstyle=\small\ttfamily,
      mathescape=true}
Il linguaggio {\cflang} \`e un'estensione del linguaggio {\flang} ed \`e
il linguaggio ``concreto'', su cui abbiamo costruito il prototipo.
Questo linguaggio, a differenza di {\flang}, ha delle costanti che sono:
i numeri interi, i numeri floating point, i valori Booleani e le stringhe.
Esso permette l'uso di coppie e liste ed esigono inoltre degli operatori 
primitivi 
per operare su di essi, come mostrato in Tabella~{\ref{tab:cfop}}.
\`E presente il costrutto di selezione ed \`e possibile il \emph{binding}
grazie al costrutto \lstinline!let!. La sintassi del linguaggio \`e mostrata in
 Tabella~\ref{tab:cfsyntax}. Vediamo ora alcuni esempi concreti per capire 
meglio cosa offre il linguaggio: 
%
\lstinputlisting{../src/examples/succ.f}
%
Questo esempio mostra la definizione della funzione \textit{successore},
che viene usata per calcolare il successore del numero intero 3.
In questo esempio si notano l'uso delle costanti (i numeri interi 1 e 3),
l'uso degli
operatori primitivi ($+$) e l'uso del costrutto \lstinline!let!, 
per definire il nome
della funzione.
Come in OCaml, la sintassi usata per la definizione della funzione
\`e la versione abbreviata di:

\begin{ScriptMath}
let succ = fun x $\to$ x + 1 in
  (succ 3)
;;
\end{ScriptMath}

Ora vediamo come viene implementata la funzione \emph{fattoriale}
che viene usata per calcolare il fattoriale del numero 10.
%
\lstinputlisting{../src/examples/fact.f}
%
In questo esempio invece si nota l'uso del costrutto \lstinline!let rec!
 per definire
una funzione ricorsiva, l'uso della selezione e l'uso dell'operatore
relazionale $=$. Mostriamo inoltre una funzione che fa uso delle
liste:
%
\lstinputlisting{../src/examples/length.f}
%
Questo esempio mostra la definizione della funzione che serve per calcolare
la lunghezza di una lista.
La costante \lstinline![]! indica la lista vuota, come anche la costante \textit{nil}. Esistono
poi le funzioni \lstinline!head! e \lstinline!tail! per accedere rispettivamente
alla testa e alla
coda di una lista.


\begin{table}%[h]
\caption{\label{tab:cfop} Operatori primitivi del linguaggio~\cflang.}
\framebox[\textwidth]{
\begin{math}
\displaystyle
\begin{array}{l|l}
  $\lstinline!+!$&$somma fra numeri interi$ \\
  $\lstinline!+.!$ &$somma fra numeri floating point$ \\
  $\lstinline!-!$ &$sottrazione fra numeri interi $ \\
  $\lstinline!-!$ \mathit{(unario)} & $negazione di un numero intero$ \\
  $\lstinline!-.!$ &$sottrazione fra numeri floating point $\\
  $\lstinline!*!$ &$moltiplicazione fra numeri interi $\\
  $\lstinline!*.!$ &$moltiplicazione fra numeri floating point $\\
  $\lstinline!/!$ &$divisione fra numeri interi $\\
  $\lstinline!/.!$ &$divisione fra numeri floating point $\\
  $\lstinline!\%!$ &$modulo fra numeri interi$\\
  $\lstinline!\%.!$ &$modulo fra numeri floating point $\\
  $\lstinline!\&\&!$ &$AND logico $\\
  $\lstinline!||!$ &$OR logico $\\
  $\lstinline!not!$ &$NOT logico $\\
  $\lstinline!=!$ &$operatore relazionale di uguaglianza $\\
  $\lstinline!<>!$ &$operatore relazionale di diversit\`a  $\\
  $\lstinline!<!$ &$operatore relazionale di minore stretto  $\\
  $\lstinline!>!$ &$operatore relazionale di maggiore stretto $\\
  $\lstinline!<=!$ &$operatore relazionale di minore o uguale $\\
  $\lstinline!>=!$ &$operatore relazionale di maggiore o uguale $\\
  $\lstinline!fst!$ &$primo elemento di una coppia $\\
  $\lstinline!snd!$ &$secondo elemento di una coppia  $\\
  $\lstinline!head!$ &$testa di una lista  $\\
  $\lstinline!tail!$ &$coda di una lista $ \\
  $\lstinline!::!$ &$concatenamento di un elemento ad una lista  $\\
\end{array}
\end{math}
}
\end{table}

\begin{table}%[h]
\caption{\label{tab:cfsyntax} Sintassi del linguaggio~\cflang.}
\framebox[\textwidth]{
\begin{math}
\displaystyle
\begin{array}{rcl@{\qquad}l}
\EXPR & ::= & \CONST \\
  & | & \VAR \\
  & | & \mathtt{fun}~\sequence{\VAR}\to\EXPR \\
  & | & \EXPR~\sequence{\EXPR} & \\
  & | & \PRIM{n}~\sequence{\EXPR} & \seqlen{\sequence{\EXPR}} = n \\
  & | & \mathtt{let}~[\mathtt{rec}]~\sequence{x} = \sequence{\EXPR}~\mathtt{in}~\EXPR \\
  & | & \mathtt{if}~\EXPR~\mathtt{then}~\EXPR~\mathtt{else}~\EXPR \\
\end{array}
\end{math}
}
\end{table}

\section{Il linguaggio \colang}

Il linguaggio {\colang} \`e un'estensione del linguaggio {\olang} e la sua 
sintassi \`e mostrata in Tabella~\ref{tab:cosyntax}.
Questo linguaggio \`e tipato e la gerarchia dei tipi \`e mostrata in
Figura~\ref{fig:type}.\footnote{La classe \textit{Applicable} \`e la classe base di ogni
funzione, e contiene i metodi necessari per applicare una funzione ai suoi
parametri.}
L'espressione $(\CLASSID)\EXPR$, sta proprio ad indicare il cast 
dell'espressione $\EXPR$ nel tipo $\CLASSID$. Il cast non era presente nel 
linguaggio {\olang} visto che questo non era tipato.
 
A differenza di {\olang} ammette anche la definizione
di metodi statici, usando la parola chiave \lstinline!static! 
prima della definizione
del metodo, o di metodi il cui corpo non contiene alcuna espressione.
Inoltre nel costrutto \lstinline!new!, non esiste pi\`u il pedice per indicare
quale \`e il valore dell'intera espressione, visto che l'allocazione di nuovi
oggetti \`e definita all'interno di un'espressione.
Per chiamare un metodo statico di una classe si usa la seguente
sintassi $\CLASSID.\METHODID(\sequence{\EXPR})$, dove $\CLASSID$ \`e il nome
della classe, $\METHODID$ \`e il nome del metodo e $\sequence{\EXPR}$ \`e la
lista dei parametri.

Come in {\cflang}, anche in questo linguaggio sono presenti le costanti,
l'operatore di selezione e il costrutto \lstinline!let!
 per effettuare il binding.
In questo caso per\`o nel binding va anche specificato qual \`e il tipo della
variabile.

\begin{figure}%[h]
\caption{\label{fig:type} Gerarchia dei tipi del linguaggio \colang}
\begin{center}
\fbox{
\includegraphics[width=\textwidth, height=0.5\textwidth]{./class}
}
\end{center}
\end{figure}


\begin{table}%[!h]
\caption{\label{tab:cosyntax} Sintassi del linguaggio \colang.}
\framebox[\textwidth]{
\begin{math}
\displaystyle
\begin{array}{rcl@{\qquad}l}
\CLASS & ::= & \mathtt{class}~\CLASSID~\mathtt{extends}~\CLASSID~\{
  \sequence{\CLASSID}~\sequence{\FIELDID};
  ~\CTOR
  ~\sequence{\METHOD}
  \} \\
\\
\CTOR & ::= & \CLASSID(\sequence{\CLASSID}~\sequence{\FIELDID})
  ~\{\THIS.\sequence{\FIELDID}=\sequence{\FIELDID};\} \\
\\
\METHOD & ::= & [\mathtt{static}]~\CLASSID~\METHODID(\sequence{\CLASSID}~\sequence{\VAR})~[\{\EXPR\}] \\
\\
\EXPR & ::= & \CONST \\
& | & \VAR \\
& | & (\CLASSID)\EXPR \\
& | & \EXPR.\FIELDID \\
& | & \EXPR.\METHODID(\sequence{\EXPR}) \\
& | & \CLASSID.\METHODID(\sequence{\EXPR}) \\
& | & \mathtt{let}~\sequence{\CLASSID}~\sequence{\VAR} = \sequence{\EXPR}~\mathtt{in}~\EXPR & \seqlen{\sequence{\VAR}} > 0 \\
& | & \mathtt{new}~\sequence{\VAR} = \sequence{\CLASSID(\sequence{\EXPR})}~\mathtt{in}~\EXPR & \seqlen{\sequence{\VAR}} > 0 \\
& | & \mathtt{if}~\EXPR~\mathtt{then}~\EXPR~\mathtt{else}~\EXPR \\
\end{array}
\end{math}
}
\end{table}

\section{Compilazione del linguaggio \cflang~nel linguaggio \colang}

La funzione di compilazione del linguaggio {\cflang} nel linguaggio {\colang}
\`e mostrata nella Tabella~\ref{tab:compplus}. Questa funzione di compilazione
\`e logicamente simile alla funzione di compilazione del linguaggio {\flang} nel
linguaggio {\olang}, mostrata in Tabella~\ref{tab:comp}.
 Per questo eviteremo di descrivere i casi gi\`a visti in
precedenza, soffermandoci invece sulle diversit\`a.\\

Una costante \lstinline!k! viene compilata come se stessa, visto che i due linguaggi 
hanno lo stesso tipo di costanti.

La compilazione di una funzione anonima comporta l'allocazione di un nuovo 
oggetto e visto che in {\colang} l'allocazione di un nuovo oggetto 
\`e definita all'interno di un'espressione, quest'espressione \`e proprio il 
nome dell'oggetto appena definito.
Essendo {\colang} tipato, nella definizione della classe
verr\`a specificato il tipo ove richiesto. Il tipo sar\`a sempre 
\lstinline!Value!, che \`e
la classe base della gerarchia dei tipi. 
 
Nell'applicazione di una funzione ai suoi parametri, viene prima effettuato
un upcast dell'espressione da applicare ad \lstinline!Applicable!, evitando cos\`i eventuali
errori di compilazione nell'invocazione del metodo \lstinline!apply!.

Gli operatori primitivi del linguaggio sono compilati con la chiamata a 
metodi statici della classe \lstinline!Prelude!, che conterr\`a quindi un metodo
per ogni operatore della Tabella~\ref{tab:cfop}.

Il \lstinline!let! e la selezione sono compilati come se stessi (a parte la compilazione
delle espressioni che contengono), visto che sono presenti in entrambi i 
linguaggi, con la sola aggiunta del tipo \lstinline!Value! nel binding delle variabili.



\begin{table}%[h]
\caption{\label{tab:compplus}\strut Compilazione del linguaggio {\cflang} nel linguaggio {\colang}.}
\framebox[\textwidth]{
\begin{small}
\begin{math}
\displaystyle
\begin{array}{rcl}
  \COMPILE{\CONST}{\sequence{y}}f &=& \CONST
  \\
  \COMPILE{x}{\sequence{y}}f &=&
  \begin{cases}
    x & x \in \sequence{y} \\
    \THIS & x = f \\
    \THIS.x & \text{altrimenti} 
  \end{cases}
  \\
  \COMPILE{\mathtt{fun}~\sequence{x} \to \EXPR}{\sequence{y}}{f} &=&
  \mathtt{new}~t = \CLASSID(\COMPILE{\sequence{z}}{\sequence{y}}{f})~\mathtt{in}~t \\
  \text{dove}
  & &
  \text{$t$ \`e fresh (non compare altrove)} \\
  & &
  \sequence{z} = \fv(\EXPR) \setminus \sequence{x} \\
  & & 
  \mathtt{class}~\CLASSID~\mathtt{extends}~\CLOSUREID{\seqlen{\sequence{x}}}~\{ \\
  & & \quad \sequence{\VALUE}~\sequence{z}; \\
  & & \quad \CLASSID(\sequence{\VALUE}~\sequence{z})~\{ \THIS.\sequence{z} = \sequence{z}; \} \\
  & & \quad \VALUE~\APPLY{\seqlen{\sequence{x}}}(\sequence{\VALUE}~\sequence{x})~\{ \COMPILE{\EXPR}{\sequence{x}}{{?}} \} \\
  & & \}
  \\
  \COMPILE{\EXPR~\sequence{\EXPR}}{\sequence{y}}{f} &=&
  ((\mathtt{Applicable})\COMPILE{\EXPR}{\sequence{y}}{f}).\APPLY{\seqlen{\sequence{\EXPR}}}(\COMPILE{\sequence{\EXPR}}{\sequence{y}}{f})
  \\
  \COMPILE{\PRIM{n}~\sequence{\EXPR}}{\sequence{y}}{f} &=&
  \mathtt{Prelude}.\PRIM{n}(\COMPILE{\sequence{\EXPR}}{\sequence{y}}{f})
  \\
  \COMPILE{\mathtt{let}~\sequence{x}=\sequence{\EXPR}~\mathtt{in}~\EXPR}{\sequence{y}}{f} &=&
  \mathtt{let}~\sequence{\VALUE}~\sequence{x}=\COMPILE{\sequence{\EXPR}}{\sequence{y}}{f}~\mathtt{in}~\COMPILE{\EXPR}{\sequence{x},\sequence{y}}{f}
  \\
  \COMPILE{\mathtt{let}~\mathtt{rec}~\sequence{f}=\sequence{\mathtt{fun}~\sequence{x}\to\EXPR}~\mathtt{in}~\EXPR}{\sequence{y}}{f} &=& 
  \mathtt{new}~\sequence{f}=\sequence{\CLASSID(\COMPILE{\sequence{z}}{\sequence{f},\sequence{y}}{f})}~\mathtt{in}~\COMPILE{\EXPR}{\sequence{f},\sequence{y}}{f}
  \\
  \text{dove}
  & &
  \sequence{z}_i = \fv(\EXPR_i) \setminus f_i,\sequence{x}_i \\
  & & \mathtt{class}~\CLASSID_i~\mathtt{extends}~\CLOSUREID{\seqlen{\sequence{x}_i}}~\{ \\
  & & \quad \sequence{\VALUE}~\sequence{z}_i; \\
  & & \quad \CLASSID_i(\sequence{\VALUE}~\sequence{z}_i)~\{ \THIS.\sequence{z}_i = \sequence{z}_i; \} \\
  & & \quad \VALUE~\APPLY{\seqlen{\sequence{x}_i}}(\sequence{\VALUE}~\sequence{x}_i)~\{ \COMPILE{\EXPR_i}{\sequence{x}_i}{{f_i}} \} \\
  & & \}
  \\
  \COMPILE{\mathtt{if}~\EXPR_1~\mathtt{then}~\EXPR_2~\mathtt{else}~\EXPR_3}{\sequence{y}}{f} &=&
  \mathtt{if}~\COMPILE{\EXPR_1}{\sequence{y}}f~\mathtt{then}~\COMPILE{\EXPR_2}{\sequence{y}}f~\mathtt{else}~\COMPILE{\EXPR_3}{\sequence{y}}f
  \\
\end{array}
\end{math}
\end{small}
}
\end{table}

\section{Scelta del linguaggio target: Java}
\label{sec:java}

A questo punto, essendo in grado di ottenere codice {\colang} a partire da codice
{\cflang}, bisogna decidere come procedere il lavoro e le possibili scelte sono le seguenti:

\begin{enumerate}
\item{Scrivere un interprete per {\colang}.}
\item{Compilare {\colang} in un linguaggio di programmazione.}
\item{Compilare {\colang} nella Java Virtual Machine~\cite{jvm}.}
\end{enumerate}

La prima alternativa \`e stata scartata perch\'e, pur essendo valida, \`e la meno ``concreta'', nel 
senso che non fornisce dei risultati pratici, su cui poi fare degli esperimenti.

Essendo molti i linguaggi di programmazione a oggetti candidati come linguaggio target di questo 
compilatore, bisogna capire quale tra questi \`e il migliore per le nostre necessit\`a.
Per decidere quale scegliere, bisogna capire quali sono i costrutti di {\colang} mappabili in maniera
naturale nel linguaggio target e quali invece sono pi\`u difficili da trattare.
Analizzando la sintassi del linguaggio {\colang}, si vede che sono solo due i casi difficili
da gestire:\label{localName}

\begin{center}
 $\mathtt{let}~\sequence{\CLASSID}~\sequence{\VAR} = \sequence{\EXPR}~\mathtt{in}~\EXPR$\\ 
 $\mathtt{new}~\sequence{\VAR} = \sequence{\CLASSID(\sequence{\EXPR})}~\mathtt{in}~\EXPR$
\end{center}  

Queste due espressioni infatti, definiscono dei nomi che sono visibili solo in un
ambiente locale.

Nel linguaggio a oggetti OCaml~\cite{ocaml} non sarebbe un problema la compilazione di
queste espressioni visto che \`e presente l'istruzione \lstinline!let!.
Per\`o OCaml \`e l'estensione del linguaggio funzionale Caml Light~\cite{caml} con in pi\`u i costrutti 
per la programmazione ad
oggetti. Quindi non \`e stato scelto come linguaggio target in quanto essendo l'estensione
a oggetti di un linguaggio funzionale la compilazione di un linguaggio funzionale in
un altro linguaggio funzionale che consente anche la creazione di oggetti non \`e molto
interessante. 
Purtroppo noi non conosciamo altri linguaggi a oggetti che permettano di definire dei nomi locali
all'interno di un'espressione, quindi i vari linguaggi a oggetti a noi noti sono equivalenti.
Visto che il linguaggio {\colang} \`e ispirato a Featherweight Java abbiamo deciso di 
scegliere come linguaggio target Java.

La compilazione verso la Java Virtual Machine non presenta il problema della definizione
di nomi locali ma essendo la compilazione in s\`e pi\`u complicata, per problemi di
tempo non \`e stata implementata.
Infatti la Java Virtual Machine usa un linguaggio tipato che comporta quindi la scrittura
di un \emph{typechecker} non banale necessario per la compilazione.

\subsection {Compilazione dal linguaggio \colang~a Java }

\subsubsection {Implementazione della gerarchia dei tipi}

Prima di descrivere la compilazione vera e propria da {\colang} a Java, bisogna
definire le classi Java che rappresentano i tipi di dati primitivi in {\colang}.
La gerarchia dei tipi di {\colang} \`e mostrata in Figura~\ref{fig:type}. 

La classe base di ogni tipo di dato \`e \lstinline!Value!. 
Questa classe non ha
alcun campo e ha un solo metodo \lstinline!toString!, che permette di trasformare
l'oggetto in stringa. Questo metodo sar\`a poi sovrascritto da ogni classe
che deriva da \lstinline!Value!, in cui ha senso la trasformazione in stringa.

La classe \lstinline!Applicable! deriva da \lstinline!Value! ed 
\`e la classe che contiene 
i metodi necessari per applicare una funzione ai suoi argomenti.
La classe contiene quindi \lstinline!n! metodi, con \lstinline!n! che rappresenta il numero
massimo di parametri che pu\`o avere una funzione.
I metodi hanno la seguente struttura:

\begin{center}
%\framebox[\textwidth]{
$\mathtt{public~abstract~Value~apply\_n~(Value~a\_1~\cdots~Value~a\_n)~}$
%}
\end{center} 

Questi metodi sono astratti visto che saranno poi sovrascritti 
dalle classi di supporto runtime e
dalle classi che mappano le funzioni.

Le classi \lstinline!Int!, \lstinline!Bool!, \lstinline!String! e 
\lstinline!Float!, rappresentano i tipi
di dati primitivi del linguaggio {\colang} e hanno la seguente struttura:
\\

\makebox[\textwidth]{
\begin{math}
\begin{array}{l}
\mathtt{public~class~\type{}~extends~Value~\{}\\
\quad \mathtt{private~final~\typep~value;}\\
\quad \mathtt{public~\type{}~(\typep~value)~\{}\\
\quad \quad \mathtt{this.value~=~value;}\\
\quad \}\\  
\quad \mathtt{public~\typep~value()~\{}\\
\quad \quad \mathtt{return~this.value;}\\
\quad \}\\
\quad \mathtt{public~java.lang.String~~toString()~\{\cdots\}}\\
\}\\
{}\\
\end{array}
\end{math}
}
%
$\type{}$ \`e il nome della classe, che va quindi sostituito
con \lstinline!Int!, \lstinline!Bool!, \lstinline!String! e \lstinline!Float!,
 mentre $\typep$ \`e il tipo di dato
primitivo in Java corrispondente. 
In Java esistono i tipi \lstinline!int, boolean! e \lstinline!float! ma il 
tipo stringa anche in Java
\`e una classe. Per questo, al fine di evitare ambiguit\`a con il tipo 
\lstinline!String! da noi
definito, quando si vuol fare riferimento al tipo \lstinline!String!
 predefinito in Java, lo
si indica usando il suo intero path \lstinline!java.lang.String!.

Ogni classe ha un solo campo di nome \lstinline!value! che serve a contenere il valore corrispondente.
Questo valore viene inizializzato dal \emph{costruttore} della classe che 
accetta come parametro un valore del tipo primitivo 
corrispondente e inizializza il campo interno con questo valore.
Inoltre la classe ha due metodi: il metodo \lstinline!value()!, che restituisce il valore
del campo della classe, e il metodo \lstinline!toString()!, che restituisce la rappresentazione
sotto forma di stringa del dato corrispondente. L'implementazione di quest'ultimo
metodo cambia in base al tipo di dato. 

Esiste anche la classe \lstinline!Pair!, necessaria per l'implementazione delle coppie e delle
liste.\footnote{Le liste non sono presenti nella gerarchia delle classi visto
che sono implementate tramite coppie.} Questa classe naturalmente ha due campi per la memorizzazione dei valori e 
questi due campi sono del tipo generico \lstinline!Value!. 
Questa classe, oltre al costruttore e al metodo 
\lstinline!toString!, ha due
metodi, chiamati \lstinline!first! e \lstinline!second!, per l'accesso al primo e al secondo elemento della
coppia.

\subsubsection{La compilazione}

Come \`e mostrato nella Tabella~\ref{tab:cosyntax}, {\colang} \`e un linguaggio
composto da \emph{espressioni}.
L'idea era quindi quella di tradurre queste espressioni in espressioni del
linguaggio Java.
In Java per\`o non esistono espressioni che permettono di introdurre dei nomi
locali, come le espressioni del linguaggio {\colang} viste nella
Sezione~\ref{sec:java} a pagina~\pageref{localName}.
Per questo abbiamo deciso di compilare le espressioni del linguaggio
{\colang} in \emph{comandi} del linguaggio Java.
In Java infatti \`e presente il comando per definire un blocco di istruzioni,
racchiuso fra parentesi
graffe, all'interno cui definire nomi locali.
Un comando per\`o a differenza di un'espressione non restituisce
alcun valore.
Per questo durante la compilazione di un'espressione all'interno di un blocco,
\`e necessario ricordarsi il nome di una variabile definita fuori dal blocco,
in cui verr\`a memorizzato il risultato della valutazione dell'espressione.
Inoltre all'interno del blocco ci saranno una serie di dichiarazioni di
variabili locali (necessarie per memorizzare i
risultati temporanei nella valutazione dell'espressione)
il cui scope \`e solo il blocco stesso.
Questo schema di compilazione \`e mostrato di seguito:

\begin{table}[h]
\makebox[\textwidth]{
\begin{math}
\begin{array}{l}
\type{}~$\lstinline!tmp!$;\\
\{\\
\quad \type{1}~$\lstinline!tmp!$_1;~\cdots~\type{n}~$\lstinline!tmp!$_n;\\
\quad \vdots \\
\quad \vdots \\
\quad $\lstinline!tmp!$~=~\COMPILE{\EXPR}{}{};\\
\}\\
\end{array}
\end{math}
}
\end{table}
\lstset{language=[Objective]Caml,
      print=true,
      basicstyle=\small\ttfamily,
      mathescape=true}
  
I nomi \lstinline!tmp, tmp$_1$, tmp$_n$! sono nomi di variabili temporanee, mentre $\type{}$, $\type{1}$ e
$\type{n}$ sono i tipi di quelle variabili. Vediamo ora come esempio 
in che modo viene compilata l'espressione aritmetica \lstinline!2 + 1!:
%
\lstinputlisting{../src/a.java}
%
Visto che quest'espressione ha due operandi, nel blocco
vengono dichiarate due variabili temporanee (\lstinline!_t0! e \lstinline!_t1!)
che saranno inizializzate con la rappresentazione nel linguaggio {\colang}
dei numeri naturali \lstinline!1! e \lstinline!2!.
Il risultato della loro somma sar\`a quindi memorizzato nella variabile 
\lstinline!res!, che \`e stata definita fuori dal blocco, e successivamente
stampato a video.

A questo punto si pone un ulteriore problema. Che tipo usare per la
dichiarazione delle variabili?
Si potrebbe pensare di usare sempre il tipo \lstinline!Value!, che \`e il supertipo del linguaggio
{\colang}. Ma, cos\`i facendo, che senso avrebbe il cast? 
Cio\`e, castando un'espressione ad \lstinline!Applicable!,
 in una variabile di tipo 
\lstinline!Value!, perderemo
l'effetto del cast; questo logicamente non \`e ci\`o che vogliamo.  

A causa di questo problema si \`e avuta la necessit\`a di creare un semplice
typechecker per il nostro linguaggio.
Lo scopo fondamentale di questo typechecker \`e proprio discriminare le espressioni
il cui tipo deriva da \lstinline!Applicable!, da tutte le altre. Infatti queste espressioni 
devono poter invocare i metodi che implementano l'applicazione di una funzione
ad una lista di espressioni.
Senza l'uso del typechecker e usando per ogni variabile il tipo 
\lstinline!Value!, la chiamata
ad un metodo \lstinline!apply!, causerebbe un errore di compilazione.
 Vediamo di seguito un esempio di programma che non fa uso del typechecker,
dichiarando quindi tutte le variabili di tipo \lstinline!Value!:

\makebox[\textwidth]{
\lstset{language=[Objective]Caml,
      print=true,
      basicstyle=\small\ttfamily,
      mathescape=true,
      numbers=left, 
      numberstyle=\tiny}
\lstinputlisting{../src/notype.java}
}\\
Supponendo di avere una classe di nome \lstinline!function! che rappresenta una funzione, questo frammento di codice rappresenta l'applicazione della funzione
al numero 3. Alla riga 4 per\`o viene memorizzato in una variabile
di tipo \lstinline!Value! il risultato del cast
ad \lstinline!Applicable! di \lstinline!function!. Essendo 
\lstinline!Applicable! un sottotipo di \lstinline!Value! l'uso del 
cast \`e inutile e la chiamata alla riga 9 del metodo \lstinline!apply1! 
su \lstinline!_t4!
causer\`a quindi un errore di compilazione, dal momento che il tipo 
\lstinline!Value! non ha il metodo \lstinline!apply1!.\\

Per il resto, la compilazione di {\colang} in Java \`e abbastanza naturale.
Infatti quasi tutti i costrutti di {\colang} sono disponibili in Java.
Come abbiamo gi\`a visto gli unici costrutti non mappabili direttamente in
java sono il \lstinline!let in! e il \lstinline!new in!.

Per quanto riguarda il \lstinline!let in!, questo viene compilato semplicemente tramite
l'uso del blocco di istruzioni racchiuso fra parentesi graffe, visto in precedenza.
Cio\`e, per ogni \textit{binding} viene generata una variabile locale al blocco e gli
viene associato il relativo valore. Poi viene compilata l'espressione in cui
sono visibili i \textit{binding} all'interno dello stesso blocco. Ad esempio
il seguente frammento di codice:

\lstinputlisting{../src/examples/letin.f}
%
viene compilato cos\`i:
\lstinputlisting{../src/letin.java}

La compilazione del \lstinline!new in!, invece, avviene disaccoppiando l'allocazione dell'oggetto
dalla sua inizializzazione.
Infatti la sua compilazione avviene in due fasi.
Nella prima fase, vengono allocati i vari oggetti, chiamando il costruttore standard
della classe. Nella seconda fase, invece, viene invocato il metodo di inizializzazione
\lstinline!__inithWith()!, su ogni nuovo oggetto creato. Questo metodo ha come parametri i
valori di inizializzazione dei campi dell'oggetto e si limita ad inizializzare
i campi con i valori passati.\\

Vediamo ora come viene compilata la funzione \textit{fattoriale} vista nella Sezione 
\ref{sec:cflang}, mostrando prima la compilazione da {\cflang} a {\colang} e
successivamente la compilazione da {\colang} a Java:\\ 

\lstset{language=[Objective]Caml,
      print=true,
      basicstyle=\small\ttfamily,
      mathescape=true}

\makebox[\textwidth]{
\begin{tabular}{lc@{\qquad}l@{\quad}l}
\lstinline!let rec fact n =! & &\lstinline!new fact = C() in!& \\
\lstinline!if n = 0 then 1 else! & &\lstinline!((Applicable)fact).apply1(10)!& \\
\quad \lstinline!n * (fact (n-1)) in! &\quad $\xrightarrow[\quad]{}$ & &\\
\lstinline!(fact 10);;!& & \lstinline!class C extends Closure1 \{!&\\
& & \quad \lstinline!Value apply1(n) \{! &\\
& & \qquad \lstinline!if Prelude.eq(n,  0) then 1 else! &\\
& & \qquad\lstinline!Prelude.mul(n,! &\\ 
& & \quad\qquad\lstinline!((Applicable)this).apply1(! &\\
& & \qquad\qquad\lstinline!Prelude.sub(n, 1))) !&\\
& & \quad\lstinline!\}! &\\
& & \lstinline!\}!&\\
& & &\\
\end{tabular}
}
%
Come possiamo notare la classe {\colang} generata non ha attributi,
visto che la funzione \lstinline!fact! non accede a variabili libere. Per
questo non \`e stato creato neanche il costruttore della classe.
All'interno del metodo \lstinline!apply1! si nota inoltre l'uso
di \lstinline!this! per richiamare il metodo stesso sulll'oggetto corrente.
Prima di richiamare il metodo \lstinline!apply1! per\`o, 
viene effettuato il cast di \lstinline!this! ad \lstinline!Applicable!.
Questo upcast \`e corretto in quanto la classe \lstinline!C! deriva 
da \lstinline!Closure1! che a sua volta deriva da \lstinline!Applicable!.

La compilazione del precedente codice {\colang} genera due file java: uno 
rappresenta la classe necessaria a mappare la funzione mentre l'altro 
rappresenta la classe eseguibile. Ecco la classe che mappa la funzione: I 

\lstset{language=Java,
      print=true,
      basicstyle=\small\ttfamily,
      mathescape=true}
\lstinputlisting{../src/examples/A_C_0.java}
%
In questa classe notiamo la presenza di una serie di blocchi 
annidati.
Ogni espressione infatti \`e compilata con un blocco e se l'espressione \`e 
composta da sottoespressioni anche queste a loro volta vengono compilate con
un blocco, che sar\`a quindi annidato rispetto al blocco che 
rappresenta l'espressione completa. 
All'interno di ogni blocco vengono dichiarate una serie di variabili temporanee
necessarie a contenere gli operandi di ogni espressione e l'ultima
istruzione del blocco serve a rendere visibile i risultati delle
operazione interne, al di fuori dello stesso. 

Questa invece \`e la classe che rappresenta la classe eseguibile:

\lstinputlisting{../src/examples/a.java}

 